home *** CD-ROM | disk | FTP | other *** search
/ MacHack 1997 / MacHack 1997.toast / Hacks / Hacks ’96 / Talking Telnet / source / network / network.c < prev    next >
Text File  |  1996-06-22  |  30KB  |  1,210 lines
  1. /****************************************************************
  2. *    NCSA Telnet for the Macintosh                                *
  3. *                                                                *
  4. *    National Center for Supercomputing Applications                *
  5. *    Software Development Group                                    *
  6. *    152 Computing Applications Building                            *
  7. *    605 E. Springfield Ave.                                        *
  8. *    Champaign, IL  61820                                        *
  9. *                                                                *
  10. *    Copyright (c) 1986-1993,                                    *
  11. *    Board of Trustees of the University of Illinois                *
  12. *****************************************************************
  13. *  Revisions:
  14. *  10/87  Initial source release, Tim Krauskopf
  15. *  2/88  typedef support for other compilers (TK)
  16. *  8/88  Gaige Paulsen - support for MacTCP drivers
  17. *  1/89  TK - conversion to new drivers, minor update for new calling convention
  18. *  6/89  TK - update to MacTCP 1.0 include files and use of GetMyIPAddr()
  19. *  7/92  Scott Bulmahn - add support for 2 global structs, put cursors into an array
  20. *  11/92 Jim Browne - Fixed more bugs than I care to mention.                    
  21. *
  22. */
  23.  
  24. #ifdef MPW
  25. #pragma segment Network
  26. #endif
  27.  
  28. #include "InternalEvents.h"
  29. #include "wind.h"
  30. #include "maclook.proto.h"
  31. #include "menuseg.proto.h"
  32. #include "mainseg.proto.h"
  33. #include "MyMacTCPstructures.h"
  34. #include "network.proto.h"
  35. #include "netevent.proto.h"
  36. #include "tnae.h"
  37. #include "authencrypt.h"
  38. #include "authencrypt.proto.h"
  39.  
  40. #include "errors.proto.h"
  41. #include "telneterrors.h"
  42. #ifdef THINK_C
  43. #pragma options(!profile)
  44. #endif
  45.  
  46. #ifdef __MWERKS__
  47. #pragma profile off
  48. #endif
  49.  
  50. //#define NET_DEBUG_MUCHINFO
  51. //#define    NET_DEBUG
  52. #ifdef    NET_DEBUG
  53. char    net_debug_string[256];
  54. #define    net_debug_print(x)    putln(net_debug_string)
  55. #else
  56. #define    net_debug_print(x)    
  57. #endif
  58.  
  59. //PROTO_UPP(Notify, TCPNotify);
  60. //static    TCPIOCompletionProcPtr        OpenCompleteInit(TCPiopb *pbp);
  61. //PROTO_UPP(OpenCompleteInit, TCPIOCompletion);
  62. //static    TCPIOCompletionProcPtr        CloseCompleteInit(TCPiopb *pbp);
  63. //PROTO_UPP(CloseCompleteInit, TCPIOCompletion);
  64. //static    TCPIOCompletionProcPtr        SendCompleteInit(TCPiopb *pbp);
  65. //PROTO_UPP(SendCompleteInit, TCPIOCompletion);
  66.  
  67. static TCPIOCompletionUPP     OpenCompleteInitUPP = nil;
  68. static TCPIOCompletionUPP     CloseCompleteInitUPP = nil;
  69. static TCPIOCompletionUPP     SendCompleteInitUPP = nil;
  70. static TCPNotifyUPP            NotifyUPP = nil;
  71.  
  72.  
  73. static    void        OpenComplete(MyTCPpbPtr pbp);
  74. static    void        SendComplete(MyTCPpbPtr pbp);
  75. static    void        CloseComplete(MyTCPpbPtr pbp);
  76.  
  77. pascal void Notify(StreamPtr streamPtr, unsigned short code, Ptr uptr, 
  78.                         unsigned short terminReason, struct ICMPReport *icmpMsg);
  79.  
  80. static    wdsEntry    *getSWDS(void);
  81. static    void        returnSWDS(wdsEntry *wds);
  82. static    void        MyPBreturn(MyTCPpbPtr pbp);
  83. static    MyTCPpb        *getPB(short driver,short call, StreamPtr stream, short usernum);
  84. static    void        clearPB(MyTCPpbPtr pbp, short driver, short call, StreamPtr stream);
  85. static    OSErr        xPBControlSync(MyTCPpbPtr pbp);
  86. static    OSErr        xPBControlAsync(MyTCPpbPtr pbp, TCPIOCompletionUPP completionUPP);
  87. static    short        makestream(void);
  88. static    void        reclaim(StreamRPtr p);
  89. static    short        giveback(StreamRPtr p, wdsEntry *wds);
  90. static    void        compressfds(wdsEntry *fds);
  91. static void NetWriteZero(Ptr pointer,long size); //put this here to keep from loading and unlaoding config segment
  92. extern Cursor    *theCursors[];
  93. extern WindRec    *screens;
  94.  
  95. long        MyA5;
  96. short        TCPd = 0;                    /* refnum of TCP drivers */
  97. QHdr        gFreePBQueue;
  98. QHdr        gFreeSWDSQueue;
  99. short         numSWDS=0;                    /* Number of SWDS's ever alloc'd (PM Only) */
  100. StreamRPtr    streams[NPORTS];
  101. ip_port        nnfromport = 0;
  102. Boolean     nextIsUrgent = FALSE;        //CCP 2.7 (See NetUrgent ())
  103.  
  104. void NetWriteZero(Ptr pointer,long size)
  105. {
  106.     while (size--) *pointer++ = 0;
  107. }
  108.  
  109. /**************************************************************************/
  110.  
  111. wdsEntry    *getSWDS(void)
  112. {
  113.     short        n=0;
  114.     wdsEntry *    wds;
  115.     
  116.     if (gFreeSWDSQueue.qHead == NULL)
  117.         wds = (wdsEntry *) myNewPtrCritical( sizeof(wdsEntry) * MAX_SWDS_ELEMS);    
  118.     else
  119.         {
  120.         wds = (wdsEntry *) gFreeSWDSQueue.qHead;
  121.         Dequeue(gFreeSWDSQueue.qHead, &gFreeSWDSQueue);
  122.         }
  123.         
  124.     if (wds == NULL) {    /* sorry, cant allocate WDS (BIG PROBLEM) */
  125.         DoError(508 | NET_ERRORCLASS, LEVEL3, NULL); // <- Is 508 correct?
  126.         forcequit();
  127.         // return ((wdsEntry*) 0L); <- ?? perhaps
  128.         }
  129.  
  130.     return(wds);
  131. }
  132.  
  133. /**************************************************************************/
  134. void    returnSWDS(wdsEntry *wds)
  135. {
  136.     Enqueue((QElemPtr)wds, &gFreeSWDSQueue);
  137. }
  138.  
  139. /**************************************************************************/
  140. void MyPBreturn(MyTCPpbPtr pbp)
  141. {
  142.     Enqueue((QElemPtr)pbp, &gFreePBQueue);
  143. }
  144.  
  145. /**************************************************************************/
  146. MyTCPpb *getPB(short driver,short call, StreamPtr stream, short usernum)
  147. {
  148.     UNUSED_ARG(usernum)
  149.     MyTCPpb *pbp;
  150.  
  151.     if (gFreePBQueue.qHead == NULL)
  152.         pbp = (MyTCPpbPtr) myNewPtrCritical( sizeof(MyTCPpb) );
  153.     else
  154.         {
  155.         pbp = (MyTCPpbPtr) gFreePBQueue.qHead;
  156.         Dequeue(gFreePBQueue.qHead, &gFreePBQueue);
  157.         }
  158.         
  159.     if (pbp == NULL) {    /* sorry, cant allocate TCP buffer (BIG PROBLEM) */
  160.         DoError(508 | NET_ERRORCLASS, LEVEL3, NULL);
  161.         forcequit();
  162.         }
  163.     
  164.     memset((char *) pbp, '\0', sizeof(MyTCPpb));    
  165.     pbp->pb.ioCRefNum = driver;
  166.     pbp->pb.tcpStream = stream;
  167.     pbp->pb.csCode = call;
  168.     
  169.     return(pbp);
  170. }
  171.  
  172. /**************************************************************************/
  173. void clearPB(MyTCPpbPtr pbp, short driver, short call, StreamPtr stream)
  174. {
  175.     NetWriteZero((Ptr)pbp, sizeof(MyTCPpb));    /* BYU LSC - Default to all zeros */    
  176.     pbp->pb.ioCRefNum = driver;
  177.     pbp->pb.tcpStream = stream;
  178.     pbp->pb.csCode = call;
  179. }
  180.  
  181. /**************************************************************************/
  182. OSErr xPBControlSync(MyTCPpbPtr pbp) 
  183. { 
  184.     pbp->pb.ioCompletion = 0L;                         /* Charlie will puke if he ever sees */
  185.     return PBControl((ParmBlkPtr)(pbp),false);         /* his funtions here. -- JMB */
  186. }
  187.  
  188. /**************************************************************************/
  189. OSErr xPBControlAsync(MyTCPpbPtr pbp, TCPIOCompletionUPP completionUPP) 
  190. { 
  191. #ifndef __powerpc__
  192.     pbp->SavedA5 = MyA5;
  193. #endif
  194.     pbp->pb.ioCompletion = completionUPP; 
  195.     return(PBControl((ParmBlkPtr)(pbp),true));        /* async */
  196. }
  197.  
  198. void    SetPortType(short port, short type)
  199. {
  200.     if (port >= 0 && port < NPORTS && (streams[port] != NULL))
  201.         streams[port]->portType = type;
  202. }
  203.  
  204. short    GetPortType(short port)
  205. {
  206.     if (port >= 0 && port < NPORTS && (streams[port] != NULL))
  207.         return(streams[port]->portType);
  208.     else return(-1);
  209. }
  210.  
  211. /**************************************************************************/
  212. /*    Returns an empty stream */ 
  213. short makestream(void)
  214. {
  215.     short        pnum, i;
  216.     StreamRPtr    p;
  217.     MyTCPpbPtr    pbp;
  218.  
  219.     for ( pnum=0; (streams[pnum]!= NULL) && pnum<NPORTS; pnum++)
  220.             ;    /* BYU 2.4.16 */
  221.     
  222.     if (pnum >= NPORTS)
  223.         return(-2);
  224.  
  225.      if (!(p = streams[pnum] = (StreamRPtr) myNewPtrCritical(sizeof(StreamRec))))
  226.          return(-1);
  227.   
  228.      if ((p->buffer = (char *) myNewPtrCritical( TCPBUFSIZ)) == NULL) {
  229.          DisposePtr((Ptr)p);
  230.          streams[pnum] = 0;
  231.           return(-1);
  232.      }
  233.      if ((p->sbuffer = (char *) myNewPtrCritical( TCPBUFSIZ)) == NULL) {
  234.          DisposePtr((Ptr)p->buffer);
  235.          DisposePtr((Ptr)p);
  236.          streams[pnum] = 0;
  237.           return(-1);
  238.      }    
  239.  
  240.     
  241.     for (i=0; i<MAX_FDS_ELEMS; i++) 
  242.         {
  243.         p->fds[ i].length =0; p->fds[ i].ptr = 0L;
  244.         p->exFDS[ i].inuse=0; p->exFDS[ i].fds.length=0;p->exFDS[ i].fds.ptr=0L;
  245.         }
  246.     p->fds[0].length = TCPBUFSIZ;
  247.     p->fds[0].ptr = p->sbuffer;
  248.     p->maxFDSused=0;
  249.     p->aedata = NULL;
  250.     
  251.     pbp=getPB( TCPd, TCPCreate, (long) 0, 7);    /* BYU LSC important - Make create call */
  252.     pbp->pb.csParam.create.rcvBuff = p->buffer;
  253.     pbp->pb.csParam.create.rcvBuffLen = TCPBUFSIZ;
  254.     pbp->pb.csParam.create.notifyProc = NotifyUPP;
  255.  
  256.     if (xPBControlSync(pbp) != noError) 
  257.         DoError (512 | NET_ERRORCLASS, LEVEL2, NULL);
  258.  
  259.     p->stream = pbp->pb.tcpStream;
  260.     
  261.     net_debug_print("Made new stream");
  262.     MyPBreturn(pbp);
  263.     return(pnum);
  264. }
  265.  
  266. /**************************************************************************/
  267. /*    reclaim( p) -
  268.         reclaims buffer space to stream (from pointer p) into the FDS list  */
  269.  
  270. void reclaim(StreamRPtr p)
  271. {
  272.     short n=0, offset=0;
  273.     
  274.     while (offset < MAX_FDS_ELEMS && p->fds[offset].ptr != 0L) offset++;
  275.     
  276.     if (offset >= MAX_FDS_ELEMS) /* offset too large -- cant reclaim */        
  277.         return;
  278.         
  279.     for (n=0 ; n<MAX_FDS_ELEMS && offset< MAX_FDS_ELEMS; n++) 
  280.         {
  281.         if (p->exFDS[ n].inuse) 
  282.             {
  283.             p->fds[ offset++]=p->exFDS[ n].fds;
  284.             p->exFDS[ n].inuse = 0;
  285.             }
  286.         }
  287. }
  288.  
  289. /**************************************************************************
  290.     giveback( p, wds) - gives WDS entries back to the stream by putting them in the 
  291.          mutually exclusive buffer.
  292.     p -> stream
  293.     wds -> wds array            */
  294. short giveback(StreamRPtr p, wdsEntry *wds)
  295. {
  296.     short n=0, m=0;
  297.     
  298.     while ( n< MAX_SWDS_ELEMS && wds[n].ptr !=0L) 
  299.         {
  300.         while (m< MAX_FDS_ELEMS && p->exFDS[ m].inuse) m++;
  301.         if (m >= MAX_FDS_ELEMS)                                    // This was off by one - JMB 2.6
  302.             return(-1);                /* No room in the RECLAIMation center */
  303.         else 
  304.             {
  305.             p->exFDS[ m].inuse =1;
  306.             p->exFDS[ m].fds = wds[n];
  307.             m++;
  308.             }
  309.         n++;
  310.         }
  311.  
  312.     return 0;
  313. }
  314.  
  315. /**************************************************************************/
  316. /*    compressfds( fds)
  317.         compress an fds data structure to make everyone happy */
  318. void compressfds(wdsEntry *fds)
  319. {
  320.     short n,m,compressed;
  321.     
  322.     compressed = 0;
  323.     
  324.     while ( !compressed) {
  325.         compressed=1;
  326.         for (n=0; n< MAX_FDS_ELEMS; n++) 
  327.             {                /* Slow Forwards */
  328.             if (fds[n].ptr) 
  329.                 {                                /* Do if N exists */
  330.                 for ( m = MAX_FDS_ELEMS -1; m>=0; m--) 
  331.                     {    /* Fast Backwards */
  332.                     if (fds[m].ptr && (fds[m].ptr+fds[m].length == fds[n].ptr)) {
  333.                         fds[n].length+=fds[m].length;
  334.                         fds[n].ptr = fds[m].ptr;
  335.                         fds[m].ptr=0L;
  336.                         fds[m].length=0;
  337.                         compressed=0;
  338.                         }
  339. #ifdef CHECKBOTHWAYZ
  340.                     else 
  341.                     if (fds[n].ptr+fds[n].length == fds[m].ptr) 
  342.                         {
  343.                         fds[m].length+=fds[n].length;
  344.                         fds[n].ptr=0L;
  345.                         fds[n].length=0;
  346.                         compressed=0;
  347.                         }
  348. #endif CHECKBOTHWAYZ
  349.                     }
  350.                 }
  351.             }
  352.         }
  353.     m=0;n=0;
  354.     
  355.     /* Close the gaps */
  356.     
  357.     while (n+m < MAX_FDS_ELEMS) 
  358.         {
  359.         while (fds[n+m].ptr ==0L && n+m< MAX_FDS_ELEMS)
  360.             m++;            /* increase gap to valid entry */
  361.         if (n+m<MAX_FDS_ELEMS)
  362.             fds[n]=fds[n+m];
  363.         n++;
  364.         }
  365.     
  366.     /* Get rid of the empty spaces */
  367.     
  368.     n--;        /* for the next loop */
  369.     while (n < MAX_FDS_ELEMS)
  370.         {
  371.         fds[n].ptr=0;
  372.         fds[n++].length=0;
  373.         }
  374. }
  375.  
  376. /***************************************************************************/
  377. /*  Mnetread
  378. *   Read from a connection buffer into a user buffer.  
  379. *   Returns number of bytes read, < 0 on error
  380. * NOTE:
  381. *    current version very inefficient, but hopefully works.
  382. */
  383. short    netread(short pnum, void *buffer, short n)
  384. {
  385.     short        i;
  386.     StreamRPtr    p;
  387.     MyTCPpbPtr    pbp;
  388.     short        inQ, reqdamt;
  389.  
  390.     if (pnum < 0 || pnum >= NPORTS)            /* BYU 2.4.15 */
  391.         return(-2);
  392.  
  393.     if (NULL == (p = streams[pnum]))
  394.         return(-2);
  395.         
  396.     pbp=getPB( TCPd, TCPStatus, p->stream, 1);                /* Make status call */
  397.     if (xPBControlSync(pbp) != noError)                     /* status call bombed */
  398.         DoError (509 | NET_ERRORCLASS, LEVEL1, "Mnetread");
  399.  
  400.     if (pbp->pb.csParam.status.connectionState !=8) {
  401. #ifdef    NET_DEBUG
  402.         sprintf(net_debug_string, "CState: %d is %d",(int)pnum, (int)pbp->pb.csParam.status.connectionState);
  403.         net_debug_print(net_debug_string);
  404. #endif
  405.         MyPBreturn(pbp);
  406.         return(-1);                              /* Connection not established */
  407.         }
  408.     
  409.     inQ = pbp->pb.csParam.status.amtUnreadData;
  410.     reqdamt = n >inQ ? inQ : n;
  411.     
  412.     clearPB( pbp, TCPd, TCPRcv, p->stream);
  413.     pbp->pb.csParam.receive.rcvBuff = buffer;
  414.     pbp->pb.csParam.receive.rcvBuffLen = reqdamt;
  415.     
  416.     if (reqdamt<1) 
  417.         {                                /* Drop out if no data */
  418.         MyPBreturn(pbp);
  419.         return(0);
  420.         }
  421.     
  422.     if ((i = xPBControlSync(pbp)) != noError) {
  423.         DoError (524 | NET_ERRORCLASS, LEVEL1, NULL);
  424.         return(-1);
  425.         }
  426.         
  427.     reqdamt = pbp->pb.csParam.receive.rcvBuffLen;
  428.     if (reqdamt<inQ) 
  429.         netputuev( CONCLASS, CONDATA, pnum,0);            /* more data to get */
  430.  
  431.      /* Decrypt data */
  432.     if (p->aedata && ((tnParams *)p->aedata)->decrypting) {
  433.          unsigned char *cp = (unsigned char *)buffer;
  434.          short len = reqdamt;
  435.          
  436.          while (len-- > 0) {
  437.             *cp = decrypt((tnParams *)p->aedata, (long)(*cp));
  438.             cp++;
  439.         }
  440.     }
  441.  
  442.     MyPBreturn(pbp);
  443.     return(reqdamt);
  444. }
  445.  
  446. //makes the next buffer be sent as urgent data
  447. void netUrgent(void)
  448. {
  449.     nextIsUrgent = TRUE;
  450. }
  451. /************************************************************************/
  452. /* netwrite
  453. *  write something into the output queue, netsleep routine will come
  454. *  around and send the data, etc.
  455. *
  456. */
  457. short    netwrite(short pnum, void *buffer, short nsend)
  458. {    
  459.     StreamRPtr    p;
  460.     wdsEntry    *swds;
  461.     short        remaining, queued, n,m;
  462.     MyTCPpbPtr    pbp;
  463.     OSErr        err;
  464.  
  465. #ifdef    NET_DEBUG_MUCHINFO
  466.     sprintf(net_debug_string, "port: %d\tbuffer: %lx\tnsend %d", pnum,
  467.         (unsigned int)buffer, (int)nsend);
  468.     net_debug_print(net_debug_string);
  469. #endif
  470.  
  471.     if (pnum < 0 || pnum >= NPORTS)        /* BYU 2.4.15 */
  472.         return(-2);
  473.  
  474.     if ( (p = streams[pnum]) == NULL)
  475.         return(-2);
  476.     
  477.     if ( !nsend )
  478.         return(0);
  479.  
  480.     swds = getSWDS();
  481.     
  482.     if (swds == NULL) return(nsend);        // Duh, Mr. Bulmahn. - JMB 2.6
  483.     
  484.     reclaim( p);
  485.  
  486.     compressfds( p->fds);
  487.  
  488.     n=0; remaining = nsend;
  489.  
  490. //    if (p->fds[0].ptr == 0) DebugStr("\pArgh! fds[0] is NULL!");
  491.     
  492.     while (p->fds[n].ptr !=0 && remaining>0 ) {
  493. //        if (n >= MAX_SWDS_ELEMS) DebugStr("\pOverflowing SWDS in while loop!");
  494.         
  495.         swds[n].ptr = p->fds[n].ptr;
  496.         if ( p->fds[n].length > remaining) {
  497.             swds[n].length = remaining;
  498.             p->fds[n].length -= remaining;
  499.             p->fds[n].ptr += remaining;
  500.             remaining=0;
  501.             }
  502.         else 
  503.             {
  504.             swds[n].length =  p->fds[n].length;
  505.             remaining -= p->fds[n].length;
  506.             p->fds[n].length = 0;
  507.             p->fds[n].ptr = 0;
  508.             }
  509.         n++;
  510.         }
  511.  
  512.     if (n>p->maxFDSused) p->maxFDSused=n;
  513.     
  514.     compressfds( p->fds);
  515.  
  516.     queued = nsend-remaining;
  517.     
  518.     for(m=0; m<n; m++) {
  519. #ifdef    NET_DEBUG_MUCHINFO
  520.     sprintf(net_debug_string, "swds[m].ptr: %lx\tswds[m].length: %d", (unsigned int)swds[m].ptr, (int)swds[m].length);
  521.     net_debug_print(net_debug_string);
  522. #endif
  523.         }
  524.         
  525.     for (m=0; m<n; m++) 
  526.         {
  527.         BlockMove(buffer, swds[m].ptr, swds[m].length);    /* BYU LSC - Put data in WDS */
  528.     
  529.         /*
  530.          * encrypt if encrypting the session
  531.          */
  532.         if (p->aedata && ((tnParams *)p->aedata)->encrypting)
  533.             encrypt((tnParams *)p->aedata, (unsigned char *)swds[m].ptr, swds[m].length);
  534.         buffer=(void *)((char *)buffer + swds[m].length);
  535.         }
  536.     
  537.     swds[m].ptr = 0L;
  538.     swds[m].length=0;
  539.     
  540.     pbp=getPB( TCPd, TCPSend, p->stream, 2);            /* Make send call */
  541.     pbp->pb.csParam.send.wdsPtr = (Ptr) swds;
  542.     pbp->pb.csParam.send.pushFlag = p->push;
  543.     pbp->pb.csParam.open.ulpTimeoutValue = (SInt8)gApplicationPrefs->SendTimeout;// timeout value
  544.     pbp->pb.csParam.open.ulpTimeoutAction = 1;                // Abort
  545.     pbp->pb.csParam.open.validityFlags = 0xC0;                // Timeout and action are valid
  546.     if (nextIsUrgent)
  547.     {
  548.         nextIsUrgent = FALSE;
  549.         pbp->pb.csParam.send.urgentFlag = TRUE;
  550.     }
  551.  
  552.     p->push=0;
  553.  
  554.     if ((err = xPBControlAsync(pbp, SendCompleteInitUPP)) != noError) 
  555.         {
  556.         char temp_xvvyz[256];
  557.         
  558.         sprintf(temp_xvvyz, "netwrite: %d", err);
  559.         DoError(510 | NET_ERRORCLASS, LEVEL2, temp_xvvyz);
  560.         return(-1);
  561.         }
  562.  
  563.     return(queued);
  564. }
  565.  
  566. /**************************************************************************/
  567. /*  Mnetpush
  568. *   attempt to push the rest of the data from the queue
  569. *   and then return whether the queue is empty or not (0 = empty)
  570. *   returns the number of bytes in the queue.
  571. */
  572. short netpush(short pnum)
  573. {
  574.     StreamRPtr    p;
  575.     MyTCPpbPtr    pbp;
  576.     short        inQ;
  577.     OSErr        err;
  578.  
  579.     if (pnum < 0 || pnum >= NPORTS)        /* BYU 2.4.15 */
  580.         return(-2);
  581.  
  582.     if (NULL == (p = streams[pnum]))
  583.         return(-2);
  584.  
  585.     pbp=getPB( TCPd, TCPStatus, p->stream, 3);            /* Make status call */
  586. //#ifdef    NET_DEBUG_MUCHINFO
  587. //    sprintf(net_debug_string, "TCPd == %d", TCPd);
  588. //    net_debug_print(net_debug_string);
  589. //#endif
  590.     if ((err = xPBControlSync(pbp)) != noError) {        /* status call bombed */
  591.         char temp_xvvyz[256];
  592.  
  593.         sprintf(temp_xvvyz, "netpush: %d", err);
  594.         DoError(509 | NET_ERRORCLASS, LEVEL2, temp_xvvyz);
  595.         }
  596.         
  597.     inQ = pbp->pb.csParam.status.amtUnackedData;
  598.     MyPBreturn( pbp);
  599.     
  600.     p->push=1;
  601.     return(inQ);
  602. }    
  603.  
  604. /**************************************************************************/
  605. /*  Mnetqlen
  606. *   return the number of bytes waiting to be read from the incoming queue.
  607. */
  608. short netqlen(short pnum)
  609. {
  610.     StreamRPtr    p;
  611.     MyTCPpbPtr    pbp;
  612.     short        inQ;
  613.  
  614.     if (pnum < 0 || pnum >= NPORTS)        /* BYU 2.4.15 */
  615.         return(-2);
  616.  
  617.     if (NULL == (p = streams[pnum]))
  618.         return(-2);
  619.  
  620.     pbp=getPB( TCPd, TCPStatus, p->stream, 4);                /* Make status call */
  621.     if (xPBControlSync(pbp) != noError)                     /* status call failed */
  622.         DoError(509 | NET_ERRORCLASS, LEVEL2, "Mnetqlen");
  623.  
  624.     inQ = pbp->pb.csParam.status.amtUnreadData;
  625.     MyPBreturn( pbp);
  626.     
  627.     p->push = 1;
  628.     return(inQ);
  629. }
  630.  
  631. /**************************************************************************/
  632. /*  Mnetroom()
  633. *    return how much room is available in output buffer for a connection
  634. */
  635. short netroom(short pnum)
  636. {
  637.     StreamRPtr    p;
  638.     short        inQ, n;
  639.  
  640.     if (pnum < 0 || pnum >= NPORTS)        /* BYU 2.4.15 */
  641.         return(-2);
  642.  
  643.     if (NULL == (p = streams[pnum]))
  644.         return(-2);
  645.  
  646.     reclaim( p);
  647.     compressfds( p->fds);
  648.  
  649. #ifdef OLDM
  650.     pbp=getPB( TCPd, TCPStatus, p->stream, 5);            /* Make status call */
  651.     if (xPBControlSync(pbp) != noError) 
  652.         DoError(509 | NET_ERRORCLASS, LEVEL1, "Mnetroom");
  653.  
  654.     inQ = pbp->csParam.status.sendWindow -
  655.                 pbp->csParam.status.amtUnackedData;
  656.     MyPBreturn( pbp);
  657. #else
  658. /*#pragma unused(pbp)    /* BYU LSC */
  659. #endif
  660.  
  661.     inQ = n = 0;
  662.     while (p->fds[n].ptr) {
  663.     
  664.         inQ += p->fds[n].length;                /* add up free list space */
  665.         n++;
  666.         }
  667.  
  668.     return(inQ);
  669. }
  670.  
  671. /**************************************************************************/
  672. void netgetip(unsigned char *st)
  673. {
  674.     struct GetAddrParamBlock mypb;
  675.     /* long netmask; */
  676.  
  677.     net_debug_print("Attempting getmyipaddr");
  678.     
  679.     NetWriteZero((Ptr)&mypb, sizeof(struct GetAddrParamBlock));
  680.     
  681.     mypb.ioCRefNum = TCPd;            /* BYU LSC - TCP driver has to be open by now */
  682.     mypb.csCode = ipctlGetAddr;
  683.  
  684.     if (PBControl((ParmBlkPtr)&mypb, false) != noError) 
  685.         {
  686.         DoError(511 | NET_ERRORCLASS, LEVEL2, NULL);
  687.         return;
  688.         }
  689.     
  690.     BlockMove(&mypb.ourAddress, st, 4);    /* BYU LSC - copy the address */
  691.     /* netmask is here if we want it, too */
  692. }
  693.  
  694. void netfromport            /* next "open" will use this port */
  695.   ( short port)
  696. {
  697.     nnfromport = (ip_port)port;
  698. }
  699.  
  700. /**************************************************************************/
  701. /*  Mnetest?
  702. *  is a particular session established yet?
  703. *  Returns 0 if the connection is in the established state.
  704. */
  705. short netest(short pnum)
  706. {
  707.     StreamRPtr    p;
  708.     MyTCPpbPtr    pbp;
  709.     short        inQ;
  710.  
  711.     if (pnum < 0 || pnum >= NPORTS)        /* BYU 2.4.15 */
  712.         return(-2);
  713.  
  714.     if (NULL == (p = streams[pnum]))
  715.         return(-2);
  716.  
  717.     pbp=getPB( TCPd, TCPStatus, p->stream, 6);            /* Make status call */
  718.     if (xPBControlSync(pbp) != noError)
  719.         {
  720.         DoError(509 | NET_ERRORCLASS, LEVEL2, "Mnetest");
  721.         inQ = -1;
  722.         }
  723.     else 
  724.         inQ = pbp->pb.csParam.status.connectionState !=8;
  725.     MyPBreturn( pbp);
  726.     
  727.     return(inQ);
  728. }
  729.  
  730. /**************************************************************************/
  731. /*  Mnetlisten
  732. *   Listen to a TCP port number and make the connection automatically when
  733. *   the SYN packet comes in.  The TCP layer will notify the higher layers
  734. *   with a CONOPEN event.  Save the port number returned to refer to this
  735. *   connection.
  736. *
  737. *   usage:   portnum = netlisten(service);
  738. *            short service;
  739. *
  740. */
  741.  
  742. short netlisten(ip_port serv)
  743. {
  744.     short        pnum;
  745.     StreamRPtr    p;
  746.     MyTCPpbPtr    pbp;
  747.  
  748.     pnum = makestream();
  749.  
  750.     if (pnum < 0 || pnum >= NPORTS)        /* BYU 2.4.15 */
  751.         return(-2);
  752.  
  753.     if (NULL == (p = streams[pnum]))
  754.         return(-2);
  755.  
  756.     pbp=getPB( TCPd, TCPPassiveOpen, p->stream, 8);            /* Make Listen call */
  757.     
  758.     pbp->pb.csParam.open.localPort = serv;
  759.     
  760.     if (xPBControlAsync(pbp, OpenCompleteInitUPP) != noError) 
  761.         DoError(513 | NET_ERRORCLASS, LEVEL2, NULL);
  762.  
  763.     return(pnum);                        /* BYU 2.4.16 */
  764. }
  765.  
  766. /***********************************************************************/
  767. /*  Mnetgetftp
  768. *  Provides the information that ftp needs to open a stream back to the
  769. *  originator of the command connection.  The other side's IP number
  770. *  and the port numbers to be used to calculate the default data connection
  771. *  number.  Returns values in an integer array for convenient use in 
  772. *  PORT commands.
  773. */
  774. short    netgetftp(short pnum, ip_addr *addr, ip_port *localPort, ip_port *remotePort)
  775. {
  776.     StreamRPtr p;
  777.     MyTCPpbPtr pbp;
  778.     
  779.     if (pnum < 0)
  780.         return(-2);
  781.  
  782.     if (NULL == (p = streams[pnum]))
  783.         return(-2);
  784.  
  785.     pbp=getPB( TCPd, TCPStatus, p->stream, 9);            /* Make status call */
  786.     if (xPBControlSync(pbp) != noError) 
  787.         DoError(514 | NET_ERRORCLASS, LEVEL2, NULL);
  788.  
  789.     *addr = pbp->pb.csParam.status.remoteHost;
  790.     *localPort = pbp->pb.csParam.status.localPort;
  791.     *remotePort = pbp->pb.csParam.status.remotePort;
  792.     MyPBreturn( pbp);
  793.  
  794.     return 0;
  795. }
  796.  
  797. /**************************************************************************/
  798. /*  Open a network socket for the user. */
  799. short netxopen( ip_addr machine, ip_port service,
  800.                 short    timeout    )        // in seconds
  801. {
  802.     short        pnum;
  803.     StreamRPtr    p;
  804.     MyTCPpbPtr    pbp;
  805.  
  806.     pnum = makestream();
  807.  
  808.     if (pnum < 0)
  809.         return(-2);
  810.  
  811.     if (NULL == (p = streams[pnum]))
  812.         return(-2);
  813.  
  814.     pbp=getPB( TCPd, TCPActiveOpen, p->stream, 10);            /* Make Listen call */
  815.     
  816.     pbp->pb.csParam.open.remoteHost = machine;                /* IP # */
  817.     pbp->pb.csParam.open.remotePort = service;                /* Port */
  818.     pbp->pb.csParam.open.localPort = nnfromport;            /* My Port */
  819.     pbp->pb.csParam.open.ulpTimeoutValue = (SInt8)timeout;    // timeout value
  820.     pbp->pb.csParam.open.ulpTimeoutAction = 1;                // Abort
  821.     pbp->pb.csParam.open.validityFlags = 0xC0;                // Timeout and action are valid
  822.     nnfromport=0;                                            /* Next one is random */
  823.     
  824.     if (xPBControlAsync(pbp, OpenCompleteInitUPP) != noError) {
  825.         DoError(515 | NET_ERRORCLASS, LEVEL2, NULL);
  826.         return(-1);
  827.         }
  828.     
  829.     SetPortType(pnum, NO_TYPE);                // Is allocated to the user
  830.     
  831. #ifdef    NET_DEBUG
  832.     sprintf(net_debug_string, "TCPOpen on port #%d", pnum);
  833.     net_debug_print(net_debug_string);
  834. #endif
  835.     return(pnum);                    /* BYU 2.4.16 */
  836. }
  837.  
  838.  
  839. /**************************************************************************/
  840. /* Mnetclose
  841. *  Do appropriate actions to return connection state to SCLOSED which
  842. *  enables the memory for that port to be reused.
  843. *
  844. *    Specifically:
  845. *        o If status is closed, then release the data structures
  846. *        o If status is not close, perform bkgrd close which generates CLOSEDONE,
  847. *            which should make the session layer call us again
  848. */
  849. short netclose(short pnum)
  850. {
  851.     StreamRPtr    p;
  852.     MyTCPpbPtr    pbp;
  853.     OSErr        errorCode;
  854.     short        status;
  855.     static        short count=0;
  856.  
  857.     errorCode = 0;
  858.     
  859.     if (pnum < 0 || pnum >= NPORTS)            /* is a valid port? */
  860.         return(-1);
  861.  
  862.     if ((p = streams[pnum]) == NULL)             /* nothing there */
  863.         return (1);
  864.  
  865.     pbp=getPB( TCPd, TCPStatus, p->stream, 11);            /* Make status call */
  866.     if ((errorCode = xPBControlSync(pbp)) != noError) 
  867.         {
  868.         if ( errorCode == invalidStreamPtr)
  869.         {
  870.             DoError (516 | NET_ERRORCLASS, LEVEL2, "Mnetclose");
  871.             return(-1);
  872.         }
  873.         else
  874.             {
  875.             status=0;
  876.             count =0;
  877.             }
  878.         }
  879.     else 
  880.         {
  881.         status = pbp->pb.csParam.status.connectionState;            /* The connection Status */
  882.         if (count++ ==10) 
  883.             {
  884.             status= 0;
  885.             count =0;
  886.             }
  887.         }
  888.  
  889. #ifdef    NET_DEBUG
  890.     sprintf(net_debug_string, "Mnetclose:error code=%i status=%d",(int)errorCode, status);
  891.     net_debug_print(net_debug_string);
  892. #endif
  893.  
  894.     if (status < 18 && status >2 ) {    /* We aren't closed yet ! */
  895. #ifdef    NET_DEBUG
  896.         sprintf(net_debug_string, "TCPClose being attempted state ...[%d]",status); /* Prolly because outstanding close */
  897.         net_debug_print(net_debug_string);
  898. #endif
  899.         clearPB( pbp, TCPd, TCPClose, p->stream);            /* Make Close call */
  900.         if ((errorCode=xPBControlAsync(pbp, CloseCompleteInitUPP)) != noError) 
  901.             {            /* TCP close failed */
  902.             DoError(517 | NET_ERRORCLASS, LEVEL2, "Mnetclose");
  903.             return (errorCode);
  904.             }
  905.  
  906.         /* Go ahead and return... PB is in use by Async Close call. */
  907.         return (0);                                            /* Return with OK */
  908.         }
  909.  
  910.     /* IF we got here, we must be at closed state, so free memory */
  911.  
  912. #ifdef    NET_DEBUG
  913.     sprintf(net_debug_string, "TCP being released, status = %d", status);
  914.     net_debug_print(net_debug_string);
  915. #endif
  916.  
  917.     clearPB( pbp,TCPd, TCPRelease, p->stream);            /* Make Release call */
  918.     if (xPBControlSync(pbp) != noError) 
  919.         {                /* TCP failed to be released.  Let us know... */
  920.         DoError (518 | NET_ERRORCLASS, LEVEL2, "Mnetclose");
  921.         return (-1);
  922.         }
  923.     
  924.     DisposPtr( p->buffer);                /* Free Receive Buffer */
  925.     DisposPtr( p->sbuffer);                /* Free Send Buffer */
  926.     DisposPtr((Ptr) p);                    /* Free Stream Structure */
  927.     streams[pnum]=0L;
  928.     netportencryptstate(pnum, 0);
  929.  
  930.     MyPBreturn(pbp);
  931.     return(0);
  932. }
  933.  
  934. /**************************************************************************/
  935. /*    Nuke the connection, NOW! */
  936. short    netabort(short pnum)
  937. {
  938.     StreamRPtr    p;
  939.     MyTCPpbPtr    pbp;
  940.     OSErr        errorCode = noErr;
  941.  
  942.     if (pnum < 0 || pnum >= NPORTS)            /* is a valid port? */
  943.         return(-1);
  944.  
  945.     if ((p = streams[pnum]) != NULL)     /* something there */
  946.         {            
  947.         pbp=getPB( TCPd, TCPAbort, p->stream, 12);            /* Make Close call */
  948.         if ((errorCode=xPBControlSync(pbp)) != noError)         /* TCP abort failed.  Bad news */
  949.             DoError (519 | NET_ERRORCLASS, LEVEL1, NULL);
  950.         clearPB( pbp,TCPd, TCPRelease, p->stream);            /* Make Close call */
  951.         if (xPBControlSync(pbp) != noError) 
  952.             {
  953.             DoError (518 | NET_ERRORCLASS, LEVEL2, NULL);
  954.             return(-1);
  955.             }
  956.         }
  957.     else
  958.         return(1);
  959.     
  960.     DisposPtr( p->buffer);                /* Free Receive Buffer */
  961.     DisposPtr( p->sbuffer);                /* Free Send Buffer */
  962.     DisposPtr((Ptr) p);                    /* Free Stream Structure */
  963.     streams[pnum]=0L;
  964.  
  965.     MyPBreturn(pbp);
  966.     return(0);
  967. }
  968.  
  969.  
  970. /**************************************************************************/
  971. /*  Mnetinit
  972. *   Calls all of the various initialization routines that set up queueing
  973. *   variables, static values, reads configuration files, etc.
  974. */
  975.  
  976. void Mnetinit( void)
  977. {
  978.     short    i;
  979.     OSErr    err;
  980.  
  981. #ifndef __powerpc__    
  982.     MyA5 = SetCurrentA5();
  983. #endif
  984.     
  985.     for (i=0; i<NPORTS;i++) {
  986.         streams[i]= (StreamRPtr) 0;
  987.         } 
  988.         
  989.     gFreePBQueue.qHead = NULL;
  990.     gFreePBQueue.qTail = NULL;
  991.     gFreePBQueue.qFlags = 0;
  992.     gFreeSWDSQueue.qHead = NULL;
  993.     gFreeSWDSQueue.qTail = NULL;
  994.     gFreeSWDSQueue.qFlags = 0;
  995.         
  996.     if ((err = OpenDriver("\p.IPP",&TCPd)) != noError)         /* cant open the IP driver */
  997.         {    
  998.         SetCursor(theCursors[normcurs]);
  999.         FatalAlert(CANT_OPEN_MACTCP, 300, err);        // Doesn't return!
  1000.         }
  1001. }
  1002.  
  1003.  
  1004.  
  1005. /*************************************************************************/
  1006. /*  Mnetshut
  1007. *   Close all the connections and turn off the hardware.
  1008. */
  1009. void netshut(void)
  1010. {
  1011.     short    i;
  1012.  
  1013.     for (i=0; i < NPORTS ; i++) 
  1014.         if (streams[i] != (StreamRPtr) NULL)
  1015.             netabort(i);                        /* Prolly should abort */
  1016. }
  1017.  
  1018. /**************************************************************************/
  1019. short    findbystream(StreamPtr streamPtr)
  1020. {
  1021.     short    pnum=0;
  1022.     
  1023.     while (pnum<NPORTS &&
  1024.             ( (streams[pnum] ==(StreamRPtr)0L) || (streamPtr !=streams[pnum]->stream)))
  1025.         pnum++;
  1026.     if (pnum >=NPORTS)
  1027.         return(-1);
  1028.     else
  1029.         return(pnum);
  1030. }
  1031.  
  1032.  
  1033. /**************************************************************************/
  1034. pascal void Notify(StreamPtr streamPtr, unsigned short code, Ptr uptr, 
  1035.                         unsigned short terminReason, struct ICMPReport *icmpMsg)
  1036. {
  1037.     UNUSED_ARG(uptr)
  1038.     UNUSED_ARG(terminReason)
  1039.     UNUSED_ARG(icmpMsg)
  1040.     StreamRPtr    p;
  1041.     short        pnum;
  1042.     
  1043.     pnum = findbystream(streamPtr);
  1044.     
  1045.     if (pnum < 0 || (p = streams[pnum]) == 0L)
  1046.         return;
  1047.     
  1048.     switch( code) {
  1049.         case TCPTerminate:
  1050.         case TCPClosing:
  1051.             netputevent(CONCLASS, CONCLOSE, pnum,0);
  1052.             break;
  1053.         case TCPULPTimeout:
  1054.             netputevent(CONCLASS, CONFAIL, pnum,0);
  1055.             break;
  1056.         case TCPDataArrival:
  1057.         case TCPUrgent:
  1058.             netputuev(CONCLASS, CONDATA, pnum,0);
  1059.             break;
  1060.         case TCPICMPReceived:
  1061.         default:
  1062.             break;
  1063.         }
  1064.     return;
  1065. }
  1066.  
  1067. /**************************************************************************/
  1068. static void OpenCompleteInit(TCPiopb *pbp)
  1069. {
  1070.     long        saveA5;
  1071.     MyTCPpbPtr    myptr;
  1072.     
  1073.     myptr = (MyTCPpbPtr)pbp;
  1074.  
  1075. #ifndef _powerpc_
  1076.     saveA5 = SetA5(myptr->SavedA5);
  1077. #endif
  1078.  
  1079.     OpenComplete(myptr);
  1080.  
  1081. #ifndef _powerpc_
  1082.     SetA5(saveA5);
  1083. #endif
  1084. }
  1085.  
  1086. /**************************************************************************/
  1087. void    OpenComplete(MyTCPpbPtr pbp)
  1088. {
  1089.     StreamRPtr    p;
  1090.     short        pnum;
  1091.  
  1092.     pnum= findbystream(pbp->pb.tcpStream);
  1093.     
  1094.     if (pnum < 0 || (p = streams[pnum]) == 0L) { 
  1095.         MyPBreturn(pbp); //BUGG:  Shouldn't we return here so we don't MyPBreturn twice? 
  1096.         return;             //I'll assume so (CCP)
  1097.     }
  1098.     if (pbp->pb.ioResult !=noError) 
  1099.         netputevent(CONCLASS, CONFAIL, pnum,pbp->pb.ioResult);    /* Failure ... */
  1100.     else 
  1101.         netputevent(CONCLASS, CONOPEN, pnum,0);            /* Success ! */
  1102.     
  1103.     MyPBreturn( pbp);
  1104. }
  1105.  
  1106. /**************************************************************************/
  1107. void    SendComplete(MyTCPpbPtr pbp)
  1108. {
  1109.     StreamRPtr    p;
  1110.     short        pnum;
  1111.     wdsEntry    *swds;
  1112.  
  1113.     swds = (wdsEntry *) pbp->pb.csParam.send.wdsPtr;
  1114.     
  1115.     pnum = findbystream(pbp->pb.tcpStream);
  1116.     
  1117.     if (pnum < 0 || (p = streams[pnum]) == 0L) {
  1118.         MyPBreturn(pbp);
  1119.         return;
  1120.         }
  1121.         
  1122.     MyPBreturn( pbp);
  1123.     giveback( p, (wdsEntry *) pbp->pb.csParam.send.wdsPtr);    /* BYU LSC - Give this back.... NOW */
  1124.     returnSWDS( swds);
  1125. }
  1126.  
  1127.  
  1128. /**************************************************************************/
  1129. static void SendCompleteInit(TCPiopb *pbp)
  1130. {
  1131.     long        saveA5;
  1132.     MyTCPpbPtr    myptr;
  1133.     
  1134.     myptr = (MyTCPpbPtr)pbp;
  1135.  
  1136. #ifndef _powerpc_
  1137.     saveA5 = SetA5(myptr->SavedA5);
  1138. #endif
  1139.     
  1140.     SendComplete(myptr);
  1141.     
  1142. #ifndef _powerpc_
  1143.     SetA5(saveA5);
  1144. #endif
  1145. }
  1146.  
  1147. /**************************************************************************/
  1148. void    CloseComplete(MyTCPpbPtr pbp)
  1149. {
  1150.     StreamRPtr    p;
  1151.     short        pnum;
  1152.  
  1153.     pnum= findbystream(pbp->pb.tcpStream);
  1154.     
  1155.     if (pnum < 0 || (p = streams[pnum]) == 0L)
  1156.       {
  1157.         netputevent(SCLASS, CLOSEDONE+1, pnum,0);
  1158.         MyPBreturn(pbp);
  1159.         return;
  1160.       }
  1161.         
  1162.     if (pbp->pb.ioResult !=noError) 
  1163.         netputevent(SCLASS, CLOSEDONE+1, pnum,0);
  1164.     else 
  1165.         netputevent(SCLASS, CLOSEDONE, pnum,0);            /* Success ! */
  1166.  
  1167.     MyPBreturn( pbp);
  1168. }
  1169.  
  1170. /**************************************************************************/
  1171. static void CloseCompleteInit(TCPiopb *pbp)
  1172. {
  1173.     long        saveA5;
  1174.     MyTCPpbPtr    myptr;
  1175.     
  1176.     myptr = (MyTCPpbPtr)pbp;
  1177.  
  1178. #ifndef _powerpc_
  1179.     saveA5 = SetA5(myptr->SavedA5);
  1180. #endif
  1181.     
  1182.     CloseComplete(myptr);
  1183.     
  1184. #ifndef _powerpc_
  1185.     SetA5(saveA5);
  1186. #endif
  1187. }
  1188.  
  1189. short netportencryptstate (short port, Ptr edata)
  1190. {
  1191.     StreamRPtr    p;
  1192.  
  1193.     if (port < 0 || port >= NPORTS)
  1194.          return(-2);
  1195.  
  1196.      if ((p = streams[port]) == NULL)
  1197.          return(-2);
  1198.  
  1199.     p->aedata = edata;
  1200.  
  1201.      return 0;
  1202. }
  1203. void networkUPPinit(void)
  1204. {
  1205.     OpenCompleteInitUPP  =     NewTCPIOCompletionProc(OpenCompleteInit);
  1206.     CloseCompleteInitUPP =     NewTCPIOCompletionProc(CloseCompleteInit);
  1207.     SendCompleteInitUPP  =     NewTCPIOCompletionProc(SendCompleteInit);
  1208.     NotifyUPP             =  NewTCPNotifyProc(Notify);
  1209. }
  1210.